#ifndef TESTSDL_H_
#define TESTSDL_H_

#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
#include <math.h>
#include <iostream>
#include <string.h>
#include "Test.h"

#include "ImageBMP.h"
#include "Pantalla.h"
#include "Color.h"



class TestSDL : public Test {

ImageBMP* imagen;

public:
	
	TestSDL(){
	}

	void imprimirDimensiones(ImageBMP *imgBMP, char* nombreImagen){
		SDL_Surface * imagen = imgBMP->getImage();
		int altoImagen = imagen->h;
		int anchoImagen = imagen->w;
		printf("%s\n",nombreImagen);
		printf("  alto = %d\n", altoImagen);
		printf("  ancho = %d\n", anchoImagen);
	}


	///INICIO DE TEST RECORTAR IMAGEN---------------------------------------
	///---------------------------------------------------------------------
	/*ImageBMP* testRecortar(Pantalla *pantalla, ImageBMP *img){
		//para saber las dimensiones de las imagenes actualmente
		imprimirDimensiones(img, "tux.bmp");
	    
		//colocar la imagen original en la pantalla, esquina superior izquierda
		pantalla->agregarImagen(img, 10, 10);

		///SE RECORTA LA IMAGEN---------------------------------------------
		//la mitad de arriba
		ImageBMP* imagenRecortada1 = new ImageBMP(img->recortarEnOtro(0, 0, img->getAncho(), (img->getAlto())*0.5));
		//mitad de abajo
		ImageBMP* imagenRecortada2 = new ImageBMP(img->recortarEnOtro(0,((img->getAlto())*0.5)+1,img->getAncho(),(img->getAlto())-((img->getAlto())*0.5)));   
		//mitad de la izquierda
		ImageBMP* imagenRecortada3 = new ImageBMP(img->recortarEnOtro( 0,0,(img->getAncho())*0.5,img->getAlto()));                             
		//mitad de la derecha
		ImageBMP* imagenRecortada4 = new ImageBMP(img->recortarEnOtro( ((img->getAncho())*0.5)+
			1,0,(img->getAncho())-((img->getAncho())*0.5),(img->getAlto()))); 
		//rectangulo central, sabiendo que divido el mismo en 16 cuadraditos iguales
		ImageBMP* imagenRecortada5 = new ImageBMP(img->recortarEnOtro((img->getAncho())*0.25,(img->getAlto())*0.25,
			(img->getAncho())*0.5,(img->getAncho())*0.5));  
	    

		//se dibuja las imegenes ya recortadas en la misma pantalla.
		int separacionEntreRecortes = 20;
		pantalla->agregarImagen(imagenRecortada1, img->getAncho() + separacionEntreRecortes, 10);
		pantalla->agregarImagen(imagenRecortada2, img->getAncho() + separacionEntreRecortes,( ((img->getAlto())/2)+1) + separacionEntreRecortes);
		pantalla->agregarImagen(imagenRecortada3, ((img->getAncho())+separacionEntreRecortes)*2, 10);
		pantalla->agregarImagen(imagenRecortada4, ((img->getAncho())+separacionEntreRecortes)*2.5 , 10);
		pantalla->agregarImagen(imagenRecortada5, 10, img->getAncho() + separacionEntreRecortes*2);

		//para comprobar que las imagenes recortardas tiene las dimensiones esperadas
		imprimirDimensiones(imagenRecortada1, "mitad de arriba:");
		imprimirDimensiones(imagenRecortada2, "mitad de abajo:");
		imprimirDimensiones(imagenRecortada3, "mitad de la derecha:");
		imprimirDimensiones(imagenRecortada4, "mitad de abajo:");
		imprimirDimensiones(imagenRecortada5, "cuadrado central:");

		///valotes invalidos con respecto a las dimensiones del rectangulo de recorte
		///sabiendo que tux.bmp mide 295x295 pilexs
		
		// No se van a crear un rectangulo de estas dimensiones.
		ImageBMP* recorte_fault1 = new ImageBMP(img->recortarEnOtro(0,0,0,0));  
		pantalla->agregarImagen(recorte_fault1, 650,0);
	    
		ImageBMP* recorte_fault2 = new ImageBMP(img->recortarEnOtro(0,0,300,400));  
		pantalla->agregarImagen(recorte_fault2, 730,0);
	    
		ImageBMP* recorte_fault3 = new ImageBMP(img->recortarEnOtro(295,295,1,1));  
		pantalla->agregarImagen(recorte_fault3, 810,0);
	    
		ImageBMP* recorte_fault4 = new ImageBMP(img->recortarEnOtro(290,290,10,10));  
		pantalla->agregarImagen(recorte_fault4,890,0);
	    
		ImageBMP* recorte_fault5  = new ImageBMP(img->recortarEnOtro(-10,0,50,50));  
		pantalla->agregarImagen(recorte_fault5, 970,0);
	    
		ImageBMP* recorte_fault6 = new ImageBMP(img->recortarEnOtro(0,0,-10,-10));  
		pantalla->agregarImagen(recorte_fault6, 1050,0);

		ImageBMP* recorte_fault7= new ImageBMP(img->recortarEnOtro(100,100,10,10));  
		pantalla->agregarImagen(recorte_fault7, 1130,0);
	        
		//para comprobar que las imagenes recortardas tiene las dimensiones esperadas
		imprimirDimensiones(recorte_fault1, "recorte_fault1:");
		imprimirDimensiones(recorte_fault2, "recorte_fault2:");
		imprimirDimensiones(recorte_fault3, "recorte_fault3:");
		imprimirDimensiones(recorte_fault4, "recorte_fault4:");
		imprimirDimensiones(recorte_fault5, "recorte_fault5:");
		imprimirDimensiones(recorte_fault6, "recorte_fault6:");
		imprimirDimensiones(recorte_fault7, "recorte_fault7:");
	    
		///---------------------------------
		//devuelvo una imagen transformada (en este caso RECORTADA) para
		//seguir la secuencia de la transformancion: 
		//recortar->rotar->escalar(para que entre en la celda)
		return imagenRecortada5; //rectangulo central
	}
	///FIN DE TEST RECORTAR IMAGEN------------------------------------------
	///---------------------------------------------------------------------
*/
	void runTestSDL(){
		Pantalla *pantalla;
		ImageBMP *imagenRotada1, *imagenRotada2;
		ImageBMP *imagenRedimensionada1, *imagenRedimensionada2, *imagenRedimensionada3;
		ImageBMP *imagenRedimensionada4, *imagenRedimensionada5, *imagenRedimensionada6;
		ImageBMP* imagenRecortada;
		SDL_Event event;
		int i, done = 0;
		double angle = 0.0;
		 		
		pantalla = Pantalla::getInstance();

		// TEST DE COLOR
		Color *rojo = new Color(255,0,0);
		std::cout << "COLOR 1: " << rojo->getAlpha() << std::endl;
		Color *c2 = new Color(0xff,0x55,0);
		std::cout << "COLOR 2: " << c2->getAlpha() << std::endl;
		Color *c3 = new Color(Color::ROJO);
		std::cout << "COLOR 3: " << c3->getAlpha() << std::endl;
		Color *c4 = new Color("#ffee01");
		std::cout << "COLOR 4: " << c4->getAlpha() << std::endl;

		ImageBMP *fondo = new ImageBMP("fondo.bmp");

		pantalla->setFondo(fondo);

		//cargamos las imgenes que seran recortardas	
		imagen = new ImageBMP("tux.bmp");
		
		if (!imagen->getImage()){
			printf("No pude cargar gráfico img1.bmp: %s\n", SDL_GetError());
			exit(1);
		}

		imagenRecortada = testRecortar(pantalla,imagen);
			
	 
		pantalla->refrescar();

		 /// HASTA ACA PRESENTE LA IMAGEN NORMAL - Ahora hago la rotacion

		 /////////////
		 // PARAMETROS
		 ////////////
		 // Vamos a rotar el dibujo hasta que presiones una tecla
		 int anguloRotar = 65;
		 // Color de fondo 
		 //float red = 0xf9;
		 //float green = 0x84;
		 //float blue =0xEF;
		 
		 // Llamo a la funcion de rotacion.
		 ImageBMP* imgTransformada = new ImageBMP("tux.bmp");
		 imgTransformada->rotar(anguloRotar,rojo);
		 imgTransformada->redimensionar(100,100);
		 //imgTransformada->transparentar(100,rojo);

		 imagenRecortada->rotar(&imagenRotada1,anguloRotar,rojo);
		 imagenRecortada->rotar(&imagenRotada2,anguloRotar+100,rojo);

		 //reducir
		 imagenRecortada->redimensionar(&imagenRedimensionada1,130,130);
		 imagenRecortada->redimensionar(&imagenRedimensionada2,100,100);
		 imagenRecortada->redimensionar(&imagenRedimensionada3,50,50);
		 imagenRecortada->redimensionar(&imagenRedimensionada4,220,220);
		 imagenRecortada->redimensionar(&imagenRedimensionada5,350,350);

		 // Una vez rotado lo copiamos a la pantalla y mostramos la pantalla
		 //pantalla->agregarImagen(imagenRotada1,200,320);
		 pantalla->agregarImagen(imgTransformada,200,320);
		 pantalla->agregarImagen(imagenRotada2,420,320);
		 pantalla->agregarImagen(imagenRedimensionada1,0,550);
		 pantalla->agregarImagen(imagenRedimensionada2,140,550);
		 pantalla->agregarImagen(imagenRedimensionada3,250,550);

		 pantalla->refrescar();

		 pantalla->agregarImagen(imagenRedimensionada4,620,480);
		 pantalla->agregarImagen(imagenRedimensionada5,850,340);
		
		 pantalla->refrescar();
		 
		 // Esperamos que se presione una tecla para salir.
		 while(done == 0) {
			while ( SDL_PollEvent(&event) ) {
				if ( event.type == SDL_KEYDOWN )
    					done = 1;
			}
		 }

		 //return 0;

	}



	void runTest(){

		this->runTestSDL();
	}	
};

#endif